// 本地存储管理工具
class LocalStorage {
    constructor() {
        this.userKey = 'memo_users'
        this.currentUserKey = 'memo_current_user'
        this.memoKey = 'memo_data'
        this.tokenKey = 'memo_token'
        
        // 初始化存储
        this.initStorage()
    }
    
    // 初始化存储
    initStorage() {
        if (!uni.getStorageSync(this.userKey)) {
            uni.setStorageSync(this.userKey, [])
        }
        if (!uni.getStorageSync(this.memoKey)) {
            uni.setStorageSync(this.memoKey, [])
        }
        
        // 初始化超级管理员账号
        this.initSuperAdmin()
        
        // 迁移用户数据（修复头像问题）
        this.migrateUserData()
    }
    
    // 迁移用户数据，修复头像问题
    migrateUserData() {
        const users = uni.getStorageSync(this.userKey) || []
        let hasChanges = false
        
        users.forEach(user => {
            // 修复空头像或不存在的头像路径
            if (!user.avatar || user.avatar === '' || user.avatar === '/static/images/default-avatar.png') {
                user.avatar = '/static/images/logo.png'
                hasChanges = true
            }
        })
        
        if (hasChanges) {
            uni.setStorageSync(this.userKey, users)
            
            // 如果当前用户的头像被更新，也更新缓存
            const currentUser = this.getCurrentUser()
            if (currentUser) {
                const updatedUser = users.find(u => u.id === currentUser.id)
                if (updatedUser && updatedUser.avatar !== currentUser.avatar) {
                    this.setCurrentUser(updatedUser, this.getToken())
                }
            }
        }
    }
    
    // 初始化超级管理员账号
    initSuperAdmin() {
        const users = uni.getStorageSync(this.userKey) || []
        
        // 检查是否已存在超级管理员
        const adminExists = users.some(user => user.username === 'hechen' && user.isAdmin === true)
        
        if (!adminExists) {
            const adminUser = {
                id: 999999, // 固定ID
                username: 'hechen',
                name: '何陈',
                phone: '13541489881', // hechen专用手机号
                password: 'hechenyuan',
                nickname: '何陈',
                avatar: '/static/images/logo.png',
                isAdmin: true,
                createTime: new Date().toISOString(),
                updateTime: new Date().toISOString()
            }
            
            users.unshift(adminUser) // 添加到数组开头
            uni.setStorageSync(this.userKey, users)
            
            // 为管理员创建特殊的示例备忘录
            this.createAdminSampleMemos(adminUser.id)
        } else {
            // 如果管理员已存在，检查备忘录数量是否完整
            const adminUser = users.find(user => user.username === 'hechen' && user.isAdmin === true)
            const allMemos = uni.getStorageSync(this.memoKey) || []
            const adminMemos = allMemos.filter(memo => memo.userId === adminUser.id)
            
            // 如果管理员备忘录少于15条（应该有完整的日记），重新创建
            if (adminMemos.length < 15) {
                // 删除现有的管理员备忘录
                const filteredMemos = allMemos.filter(memo => memo.userId !== adminUser.id)
                uni.setStorageSync(this.memoKey, filteredMemos)
                // 重新创建完整的管理员备忘录
                this.createAdminSampleMemos(adminUser.id)
            }
        }
        
        // 检查是否已存在admin测试账号
        const testAdminExists = users.some(user => user.username === 'admin' && user.isAdmin === true)
        
        if (!testAdminExists) {
            const testAdminUser = {
                id: 888888, // 固定ID
                username: 'admin',
                name: '系统管理员',
                phone: '18290362536', // admin专用手机号
                password: 'admin123',
                email: 'admin@memo.com',
                nickname: '管理员',
                avatar: '/static/images/logo.png',
                signature: '系统测试管理员账号',
                isAdmin: true,
                createTime: new Date().toISOString(),
                updateTime: new Date().toISOString()
            }
            
            users.unshift(testAdminUser) // 添加到数组开头
            uni.setStorageSync(this.userKey, users)
            
            // 为测试管理员创建管理员相关的备忘录
            this.createTestAdminMemos(testAdminUser.id)
        } else {
            // 如果测试管理员已存在，检查备忘录数量是否完整
            const testAdminUser = users.find(user => user.username === 'admin' && user.isAdmin === true)
            if (testAdminUser) {
                const allMemos = uni.getStorageSync(this.memoKey) || []
                const testAdminMemos = allMemos.filter(memo => memo.userId === testAdminUser.id)
                
                // 如果测试管理员备忘录少于8条，重新创建
                if (testAdminMemos.length < 8) {
                    // 删除现有的测试管理员备忘录
                    const filteredMemos = allMemos.filter(memo => memo.userId !== testAdminUser.id)
                    uni.setStorageSync(this.memoKey, filteredMemos)
                    // 重新创建测试管理员备忘录
                    this.createTestAdminMemos(testAdminUser.id)
                }
            }
        }
    }
    
    // ========== 用户管理 ==========
    
    // 用户注册
    register(userData) {
        const users = uni.getStorageSync(this.userKey) || []
        
        // 检查是否使用了管理员专用的用户名
        if (userData.username === 'hechen' || userData.username === 'admin') {
            return {
                success: false,
                message: '该用户名为系统保留，请使用其他用户名'
            }
        }
        
        // 检查是否使用了管理员专用的手机号
        if (userData.phone === '18290362536' || userData.phone === '13541489881') {
            return {
                success: false,
                message: '该手机号为系统保留，请使用其他手机号'
            }
        }
        
        // 检查手机号是否已存在
        const existUser = users.find(user => user.phone === userData.phone)
        if (existUser) {
            return {
                success: false,
                message: '手机号已存在'
            }
        }
        
        // 检查用户名是否已存在
        const existUsername = users.find(user => user.username === userData.username)
        if (existUsername) {
            return {
                success: false,
                message: '用户名已存在'
            }
        }

        // 检查邮箱是否已存在（如果提供了邮箱）
        if (userData.email && userData.email.trim()) {
            const existEmail = users.find(user => user.email === userData.email)
            if (existEmail) {
                return {
                    success: false,
                    message: '邮箱已被注册'
                }
            }
        }
        
        // 创建新用户
        const newUser = {
            id: Date.now(),
            username: userData.username,
            name: userData.name,
            phone: userData.phone,
            password: userData.password,
            email: userData.email || '',
            nickname: userData.name || `用户${userData.phone.substr(-4)}`,
            avatar: userData.avatar || '/static/images/logo.png',
            signature: '这个人很懒，什么都没留下~',
            isAdmin: false, // 普通用户默认不是管理员
            createTime: new Date().toISOString(),
            updateTime: new Date().toISOString()
        }
        
        users.push(newUser)
        uni.setStorageSync(this.userKey, users)
        
        // 自动登录
        const token = this.generateToken(newUser.id)
        this.setCurrentUser(newUser, token)
        
        // 为新用户创建示例备忘录
        this.createSampleMemos(newUser.id)
        
        return {
            success: true,
            message: '注册成功',
            data: {
                userId: newUser.id,
                token: token,
                userInfo: this.getUserInfo(newUser)
            }
        }
    }
    
    // 用户登录（支持手机号或用户名）
    login(loginId, password) {
        const users = uni.getStorageSync(this.userKey) || []
        const user = users.find(u => 
            (u.phone === loginId || u.username === loginId) && u.password === password
        )
        
        if (!user) {
            return {
                success: false,
                message: '账号或密码错误'
            }
        }
        
        const token = this.generateToken(user.id)
        this.setCurrentUser(user, token)
        
        return {
            success: true,
            message: '登录成功',
            data: {
                userId: user.id,
                token: token,
                userInfo: this.getUserInfo(user)
            }
        }
    }
    
    // 生成Token
    generateToken(userId) {
        return `token_${userId}_${Date.now()}`
    }
    
    // 设置当前用户
    setCurrentUser(user, token) {
        uni.setStorageSync(this.currentUserKey, user)
        uni.setStorageSync(this.tokenKey, token)
    }
    
    // 获取当前用户
    getCurrentUser() {
        return uni.getStorageSync(this.currentUserKey)
    }
    
    // 获取Token
    getToken() {
        return uni.getStorageSync(this.tokenKey)
    }
    
    // 检查是否已登录
    isLoggedIn() {
        const token = this.getToken()
        const user = this.getCurrentUser()
        return !!(token && user && user.id)
    }
    
    // 退出登录
    logout() {
        uni.removeStorageSync(this.currentUserKey)
        uni.removeStorageSync(this.tokenKey)
    }
    
    // 获取用户信息（去除敏感信息）
    getUserInfo(user) {
        const { password, ...userInfo } = user
        return userInfo
    }
    
    // 更新用户信息
    updateUserInfo(updateData) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const users = uni.getStorageSync(this.userKey) || []
        const userIndex = users.findIndex(u => u.id === currentUser.id)
        
        if (userIndex === -1) {
            return { success: false, message: '用户不存在' }
        }
        
        // 更新用户信息
        users[userIndex] = {
            ...users[userIndex],
            ...updateData,
            updateTime: new Date().toISOString()
        }
        
        uni.setStorageSync(this.userKey, users)
        
        // 更新当前用户缓存
        this.setCurrentUser(users[userIndex], this.getToken())
        
        return {
            success: true,
            message: '更新成功',
            data: this.getUserInfo(users[userIndex])
        }
    }

    // 检查用户是否存在
    checkUserExists(username) {
        const users = uni.getStorageSync(this.userKey) || []
        return users.some(user => user.username === username)
    }

    // 检查手机号是否存在
    checkPhoneExists(phone) {
        const users = uni.getStorageSync(this.userKey) || []
        return users.some(user => user.phone === phone)
    }

    // 检查邮箱是否存在
    checkEmailExists(email) {
        if (!email) return false
        const users = uni.getStorageSync(this.userKey) || []
        return users.some(user => user.email === email)
    }

    // 根据用户名获取用户信息
    getUserByUsername(username) {
        const users = uni.getStorageSync(this.userKey) || []
        return users.find(user => user.username === username)
    }

    // 获取所有用户
    getUsers() {
        return uni.getStorageSync(this.userKey) || []
    }

    // 更新用户
    updateUser(userData) {
        const users = this.getUsers()
        const userIndex = users.findIndex(u => u.id === userData.id)
        
        if (userIndex !== -1) {
            users[userIndex] = { ...users[userIndex], ...userData }
            uni.setStorageSync(this.userKey, users)
            
            // 如果是当前用户，更新缓存
            const currentUser = this.getCurrentUser()
            if (currentUser && currentUser.id === userData.id) {
                this.setCurrentUser(users[userIndex], this.getToken())
            }
        }
    }

    // 获取用户备忘录
    getUserMemos(userId) {
        const allMemos = uni.getStorageSync(this.memoKey) || []
        return allMemos.filter(memo => memo.userId === userId)
    }

    // 获取所有数据
    getAllData() {
        return {
            users: this.getUsers(),
            memos: uni.getStorageSync(this.memoKey) || [],
            currentUser: this.getCurrentUser(),
            token: this.getToken()
        }
    }

    // 清除所有数据
    clearAllData() {
        uni.removeStorageSync(this.userKey)
        uni.removeStorageSync(this.memoKey)
        uni.removeStorageSync(this.currentUserKey)
        uni.removeStorageSync(this.tokenKey)
        
        // 重新初始化
        this.initStorage()
    }
    
    // ========== 备忘录管理 ==========
    
    // 获取备忘录列表
    getMemoList(options = {}) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        let userMemos = allMemos.filter(memo => memo.userId === currentUser.id)
        
        // 排序：根据重要性和时间排序
        userMemos.sort((a, b) => {
            // 重要的排在前面
            if (a.important && !b.important) return -1
            if (!a.important && b.important) return 1
            // 时间降序
            return new Date(b.createTime) - new Date(a.createTime)
        })
        
        // 分页处理
        const page = options.page || 1
        const pageSize = options.pageSize || 10
        const startIndex = (page - 1) * pageSize
        const endIndex = startIndex + pageSize
        
        const pagedMemos = userMemos.slice(startIndex, endIndex)
        const hasMore = endIndex < userMemos.length
        
        return {
            success: true,
            data: {
                list: pagedMemos,
                total: userMemos.length,
                hasMore: hasMore
            }
        }
    }
    
    // 获取备忘录详情
    getMemoDetail(memoId) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const memo = allMemos.find(m => m.id == memoId && m.userId === currentUser.id)
        
        if (!memo) {
            return { success: false, message: '备忘录不存在' }
        }
        
        return {
            success: true,
            data: memo
        }
    }
    
    // 创建备忘录
    createMemo(memoData) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        
        const newMemo = {
            id: Date.now(),
            userId: currentUser.id,
            title: memoData.title || '',
            content: memoData.content || '',
            category: memoData.category || 'general',
            important: memoData.important || false,
            createTime: new Date().toISOString(),
            updateTime: new Date().toISOString()
        }
        
        allMemos.push(newMemo)
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '创建成功',
            data: newMemo
        }
    }
    
    // 更新备忘录
    updateMemo(memoId, updateData) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const memoIndex = allMemos.findIndex(m => m.id == memoId && m.userId === currentUser.id)
        
        if (memoIndex === -1) {
            return { success: false, message: '备忘录不存在' }
        }
        
        // 更新备忘录
        allMemos[memoIndex] = {
            ...allMemos[memoIndex],
            ...updateData,
            updateTime: new Date().toISOString()
        }
        
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '更新成功',
            data: allMemos[memoIndex]
        }
    }
    
    // 删除备忘录
    deleteMemo(memoId) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const memoIndex = allMemos.findIndex(m => m.id == memoId && m.userId === currentUser.id)
        
        if (memoIndex === -1) {
            return { success: false, message: '备忘录不存在' }
        }
        
        allMemos.splice(memoIndex, 1)
        uni.setStorageSync(this.memoKey, allMemos)
        
        return {
            success: true,
            message: '删除成功'
        }
    }
    
    // 批量删除备忘录
    batchDeleteMemo(memoIds) {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        if (!Array.isArray(memoIds) || memoIds.length === 0) {
            return { success: false, message: '请选择要删除的备忘录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const filteredMemos = allMemos.filter(memo => 
            !(memoIds.includes(memo.id) && memo.userId === currentUser.id)
        )
        
        uni.setStorageSync(this.memoKey, filteredMemos)
        
        return {
            success: true,
            message: `成功删除${memoIds.length}条备忘录`
        }
    }
    
    // ========== 统计信息 ==========
    
    // 获取用户统计信息
    getStats() {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const userMemos = allMemos.filter(memo => memo.userId === currentUser.id)
        
        // 计算使用天数
        const registerDate = new Date(currentUser.createTime)
        const now = new Date()
        const diffTime = Math.abs(now - registerDate)
        const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24))
        
        // 分类统计
        const categoryStats = {}
        userMemos.forEach(memo => {
            const category = memo.category || 'general'
            categoryStats[category] = (categoryStats[category] || 0) + 1
        })
        
        // 重要备忘录数量
        const importantCount = userMemos.filter(memo => memo.important).length
        
        return {
            success: true,
            data: {
                totalMemos: userMemos.length,
                importantMemos: importantCount,
                favoriteCount: importantCount, // 使用重要备忘录作为收藏数
                registerDays: diffDays,
                categoryStats: categoryStats,
                recentActivity: this.getRecentActivity(userMemos)
            }
        }
    }
    
    // 获取最近活动
    getRecentActivity(memos) {
        return memos
            .sort((a, b) => new Date(b.updateTime) - new Date(a.updateTime))
            .slice(0, 5)
            .map(memo => ({
                type: 'memo',
                title: memo.title,
                time: memo.updateTime
            }))
    }
    
    // ========== 数据管理 ==========
    
    // 导出用户数据
    exportUserData() {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const userMemos = allMemos.filter(memo => memo.userId === currentUser.id)
        
        const exportData = {
            userInfo: this.getUserInfo(currentUser),
            memos: userMemos,
            exportTime: new Date().toISOString(),
            version: '1.0.7'
        }
        
        return {
            success: true,
            data: exportData
        }
    }
    
    // 清除用户数据
    clearUserData() {
        const currentUser = this.getCurrentUser()
        if (!currentUser) {
            return { success: false, message: '用户未登录' }
        }
        
        // 删除用户的所有备忘录
        const allMemos = uni.getStorageSync(this.memoKey) || []
        const filteredMemos = allMemos.filter(memo => memo.userId !== currentUser.id)
        uni.setStorageSync(this.memoKey, filteredMemos)
        
        return {
            success: true,
            message: '数据清除成功'
        }
    }
    
    // ========== 示例数据创建 ==========
    
    // 为新用户创建示例备忘录
    createSampleMemos(userId) {
        const sampleMemos = [
            {
                id: Date.now() + 1,
                userId: userId,
                title: '欢迎使用小何备忘录！',
                content: '🎉 恭喜你成功注册小何备忘录！\n\n这是一个完全本地存储的备忘录应用，你的数据完全属于你自己，不会上传到任何服务器。\n\n✨ 主要功能：\n• 创建和管理备忘录\n• 重要备忘录标记\n• 分类管理\n• 数据导出\n• 完全离线使用\n\n开始记录你的想法吧！ 💡',
                category: 'general',
                important: true,
                createTime: new Date().toISOString(),
                updateTime: new Date().toISOString()
            },
            {
                id: Date.now() + 2,
                userId: userId,
                title: '今日任务清单',
                content: '📝 今天要完成的事情：\n\n☐ 学习新技术\n☐ 整理工作笔记\n☐ 健身锻炼\n☐ 阅读技术文档\n☐ 准备明天的会议\n\n记得保持良好的工作节奏！ 💪',
                category: 'work',
                important: false,
                createTime: new Date(Date.now() - 3600000).toISOString(),
                updateTime: new Date(Date.now() - 3600000).toISOString()
            },
            {
                id: Date.now() + 3,
                userId: userId,
                title: '购物清单',
                content: '🛒 需要购买的物品：\n\n• 新鲜蔬菜\n• 水果\n• 牛奶\n• 面包\n• 生活用品\n\n记得比较价格，选择优质商品！ 🛍️',
                category: 'life',
                important: false,
                createTime: new Date(Date.now() - 7200000).toISOString(),
                updateTime: new Date(Date.now() - 7200000).toISOString()
            }
        ]
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        allMemos.push(...sampleMemos)
        uni.setStorageSync(this.memoKey, allMemos)
    }
    
    // 重新创建管理员备忘录（强制更新）
    recreateAdminMemos() {
        const users = uni.getStorageSync(this.userKey) || []
        const adminUser = users.find(user => user.username === 'hechen' && user.isAdmin === true)
        
        if (adminUser) {
            // 删除现有的管理员备忘录
            const allMemos = uni.getStorageSync(this.memoKey) || []
            const filteredMemos = allMemos.filter(memo => memo.userId !== adminUser.id)
            uni.setStorageSync(this.memoKey, filteredMemos)
            
            // 重新创建管理员备忘录
            this.createAdminSampleMemos(adminUser.id)
            return true
        }
        return false
    }

    // 为管理员创建特殊示例备忘录
    createAdminSampleMemos(userId) {
        const adminMemos = [
            {
                id: Date.now() + 99,
                userId: userId,
                title: '欢迎小宝 💕',
                content: '亲爱的小宝，欢迎来到我们的专属备忘录世界！✨\n\n这里记录着我们一起走过的每一个美好时光，每一份珍贵的回忆。💖\n\n希望这些文字能够唤起你心中最温暖的记忆，让我们的爱情故事永远闪闪发光。🌟\n\n爱你的何陈 💕',
                category: 'life',
                important: true,
                createTime: new Date('2025-01-01T00:00:00').toISOString(), // 设置为最早的时间，但通过important标记置顶
                updateTime: new Date('2025-01-01T00:00:00').toISOString()
            },
            {
                id: Date.now() + 100,
                userId: userId,
                title: '2025.4.4晴转阴 ☁️',
                content: '这一天下午，天气似乎也变得有些阴郁，细雨如丝，悄然落下，给整个世界蒙上了一层薄薄的雾霭。我收到了这样一段话："你跟我说不喜欢，就不要吊着你。"，我的心仿佛被什么轻轻刺了一下。我试图推开你，不是因为不在乎，而是因为我害怕。我害怕自己不值得被喜欢，所以，我用试探的方式，试图去验证这份感情的真伪，试图去寻找一个答案。被你说了之后我想了很久，我现在愿意放下心中的顾虑，勇敢地去面对这份感情，去面对你。',
                category: 'life',
                important: false,
                createTime: new Date('2025-04-04T15:00:00').toISOString(),
                updateTime: new Date('2025-04-04T15:00:00').toISOString()
            },
            {
                id: Date.now() + 101,
                userId: userId,
                title: '2025.4.11 小雨转阴 🌧️',
                content: '在周四的回学校路上，这把伞突然开始下红包雨🌧️，某人偷偷在伞骨缝里塞了三张"晴天储备金"，说是给我的，这是我第一次被别人这么对待🥹',
                category: 'life',
                important: false,
                createTime: new Date('2025-04-11T17:00:00').toISOString(),
                updateTime: new Date('2025-04-11T17:00:00').toISOString()
            },
            {
                id: Date.now() + 102,
                userId: userId,
                title: '2025.4.21 晴☀️',
                content: '今天要去见她，早点起来收拾自己。我们逛了动物园，大象没上班没看见，偷偷拍她几张背影没想到被发现了 被删了www 不过呢 我们在老君洞拍了哈哈又好了。我们去抽签大师说我很幸运 什么都好，她的签被说我们会容易闹矛盾，但没关系 我会好好珍惜温柔地对她 不吵架',
                category: 'life',
                important: false,
                createTime: new Date('2025-04-21T10:00:00').toISOString(),
                updateTime: new Date('2025-04-21T10:00:00').toISOString()
            },
            {
                id: Date.now() + 103,
                userId: userId,
                title: '2025.4.22 阴☁️',
                content: '今天她要上班  我去了云端之眼  消磨时间  好累啊我的脚  上去看完拍个免费照 就走了 20块一张！不过想给她看看 买了    晚上等她到第二天早上舍不得  舍不得！！！',
                category: 'life',
                important: false,
                createTime: new Date('2025-04-22T14:00:00').toISOString(),
                updateTime: new Date('2025-04-22T14:00:00').toISOString()
            },
            {
                id: Date.now() + 104,
                userId: userId,
                title: '2025.4.30 多云  *^_^*',
                content: '照计划说的要五一见，但我提前了一天我们都非常的开心，小宝也非常期待但她不能中午见到我了，时间来不及所以只能晚上见，6点终于等到她下班我提前点好咖啡和烤兔今天吃个不一样的，幸好到9点没有凉，小宝穿的小高跟很累脚，给她揉揉她还不要。在我手机上看电影但确实没想到看到英文她想打瞌睡哈哈  后面就～～睡觉  准备五一的行程.',
                category: 'life',
                important: false,
                createTime: new Date('2025-04-30T18:00:00').toISOString(),
                updateTime: new Date('2025-04-30T18:00:00').toISOString()
            },
            {
                id: Date.now() + 105,
                userId: userId,
                title: '2025.5.1 阴  *╭(╯ε╰)╮*',
                content: '到乐山了我们先去酒店但坐车太累了，我让小宝先睡会觉 我就出去寻觅吃的 买了甜皮鸭和一个特色什么糕和粥  我到酒店她也刚好醒了 看她挺喜欢吃这个粥 看来我买对了我吃了个绵绵冰嘿嘿  就给她看了订单 因为她感冒了 我也看了一圈 发现那些冰都不能吃  感冒快好快  姨妈也快点走 不要在折磨小宝了   揉揉肚子好受点让小宝~',
                category: 'travel',
                important: false,
                createTime: new Date('2025-05-01T16:00:00').toISOString(),
                updateTime: new Date('2025-05-01T16:00:00').toISOString()
            },
            {
                id: Date.now() + 106,
                userId: userId,
                title: '2025.5.2 晴 *→_→*',
                content: '起来吃甜皮鸭 差点没赶上打车去高铁  后面发现来不及直接打车去的峨眉山 司机说了很多 少走了很多弯路  爬山的过程 很累 停一会走一回 但没关系 我一直陪着你 上山的路上听她说 有个男生进女厕所 震惊了  我们相互扶持最终到山顶了  山顶的风光很好看 但我觉得我俩站一块的时候就是最美丽的风景 但很快就被冷🥶  风很大 我成为了你唯一的倚靠嘿嘿    我们拍完照 找住的的地放 看攻略 我们走进了一家餐厅 我俩都不好意思 点了两个汉堡 热水免费的 我们泡方便面时差点没关上 然后就坐那一直聊天 后面她有点困了 她靠着我的腿睡会 但肯定没睡着 坐到晚上 碰到一个大哥 听他说他是从山底爬上来的 佩服 后面向他聊了一会社会工作上之类的事 此时小宝还在睡 后面都累了 我也想趴一会 趴在小宝身上睡了会 后面发现还是不睡了 睡不着 我俩硬生生的坐了一晚 期间上厕所真的不方便  半夜的时候餐厅全是人 躺满了 深怕踩到人',
                category: 'travel',
                important: false,
                createTime: new Date('2025-05-02T08:00:00').toISOString(),
                updateTime: new Date('2025-05-02T08:00:00').toISOString()
            },
            {
                id: Date.now() + 107,
                userId: userId,
                title: '2025.5.3 晴  →_→*',
                content: '等到了早上6点我们出发去看日出  当时都以为不出了结果是看反方向了真是绷不住了然后我们赶紧上去 看到了日出真的特别壮观 随后坐索道下去 五一爬山的人好多  坐公交车我们还做错地方下站了 最后还是跟导航绕了回来  但没想到就是 钵钵鸡不是让我很满意  小宝说还行  可能我不太吃得生的 但鸡爪好吃😋  最后坐公交去高铁站  回成都  那天出站真的是很好玩  去酒店得去另一个广场 我们顶着大太阳到处走 虽然有伞 还走到绝路了  后面是导航的原因 经过一系列波折入住到酒店了  进酒店小宝一直躺着焉了 不想动了  说一起出去吃好吃的 和拍照但综合考虑了 还是算了  我们就洗漱躺着了 小宝真是小傻瓜hh 不能让她知道 有时候傻得可爱 但我非常喜欢╭(╯ε╰)╮',
                category: 'travel',
                important: false,
                createTime: new Date('2025-05-03T06:00:00').toISOString(),
                updateTime: new Date('2025-05-03T06:00:00').toISOString()
            },
            {
                id: Date.now() + 108,
                userId: userId,
                title: '2025.5.4 晴  →_→*',
                content: '回重庆了嘞  我们在江北 这个酒店真的难找 还变号了 从一栋楼跑到另一栋楼  不过环境还不错就是这个卫生间差评了 有个小安排 要和李帆他们唱歌和玩  小宝画了妆 可能时间有点点急 美瞳戴了3次才带进去 我当了小下手  画完了 小宝漂亮极了 比平时更美了我们先到的ktv 唱了很多首歌 印象最深的是她唱奇妙能力歌  很好听完全能出道了哈哈赶紧出去给我挣钱养我 宝宝😉😉 唱完之后我们去一个小酒馆边吃饭边看乐队唱歌  你知道吗小宝 我们对视的时候 我觉得自己好像爱上你了 想视为最宝贵的东西珍惜着  后面十点后的乐队那个大哥好厉害唱歌 李帆他们时间原因先走了  我们在看了一会也回酒店了 我带的隐形眼镜很干 回去赶紧摘掉  然后我让你不开心了  因为在电梯里你发现我在看别人   我真的只是看一眼那个男的 后面那女生跟上去恰好你也看我在看什么就这样了  小宝才是最好看的 所以不要误会我了 不要不开心  后面这个不愉快的事情过去了 我俩互相看对方以前的照片 了解其以往的生活嘿嘿😬',
                category: 'life',
                important: false,
                createTime: new Date('2025-05-04T15:00:00').toISOString(),
                updateTime: new Date('2025-05-04T15:00:00').toISOString()
            },
            {
                id: Date.now() + 109,
                userId: userId,
                title: '2025.5.5 多云 ╭(╯ε╰)╮',
                content: '醒的很早  我不想分别 所以小宝很早就被我喊醒了  珍惜每一秒和你在一起的时间 一眨眼时间就过去了  但是我想说和你在一起 一天顶我平常生活的一周→_→ 下酒店的时候坐一会你一句是不是鞋忘拿了  我才想起来  差点就让几百块赔在酒店了  然后一起吃了面 我是排骨你是牛肉 想定格在互相夹肉的瞬间 这样我们就一直冻结在那  后面打车去高铁站你陪我到那  心里很感动你还说我没看你  傻瓜 我默默注视你的时候你都没回头呢 你一人提着行李箱回去我也很心疼担心是否错过站 担心这担心那  然后我坐车回学校感觉人都要坐哈了  手机又摔了一下 回到寝室我就躺着一动不动 你也刚好到家了 😬😬',
                category: 'life',
                important: false,
                createTime: new Date('2025-05-05T07:00:00').toISOString(),
                updateTime: new Date('2025-05-05T07:00:00').toISOString()
            },
            {
                id: Date.now() + 110,
                userId: userId,
                title: '2025.5.8 多云 ⊙﹏⊙',
                content: '6点起床 收拾准备去比赛了 比完就和你说了我已经成功请到假了嘞 老师也同意了 哼刚以为你说明天是星期六 不想见我 我超想你的啊  只想见你 还以为你不想见我了  原来只是觉得在一起的时间会少╭(╯ε╰)╮互相挂念 我高兴 中午和老师吃完饭 马不停蹄坐地铁到酒店  没想法酒店就在你们小区门口 光看离锦绣广场近了 发呆等啊等 9点你终于下班了 不过下雨了  我担心怕你被淋雨 都想直接过来拿伞接你  不过你回消息都已经在小区门口了  我知道你是不想让我太担心  跟着导航走的时候你还说我是反方向 我要笑到了哈哈  扭头就看到你了  我已为小宝准备好了奶茶和火锅 你居然提前吃了一些东西还是冰的还没跟我说 哼哼  不过你说是报复之前在乐山的时候 以后可不能这样了嘞  4日没见恍如隔世了 陪你一起走上班的路 不过好困宝宝  抱抱 回酒店我睡着了超困  真是辛苦宝宝挺着困意上班上那么久  期待期待下次见面^O^  520',
                category: 'life',
                important: false,
                createTime: new Date('2025-05-08T06:00:00').toISOString(),
                updateTime: new Date('2025-05-08T06:00:00').toISOString()
            },
            {
                id: Date.now() + 111,
                userId: userId,
                title: '2025.5.18   大太阳*^_^*',
                content: '收到宝贝临时通知不能多休一天换地方了  我想着就今天休息 我改签早点去  第二天晚上等小宝 小宝小宝别太难过了 刚刚好抢到最后一票  差一点就都没了 这次选到地铁站门口的酒店真好  我比宝宝先到先入住 等宝宝 外面好晒啊 我给宝宝准备了两个礼物 明天晚上12点给你看  要期待 宝宝说给我买的手表  你宝宝为什么我一看到你就觉得自己又是很久很久没看到你 好想你 每一秒都要珍惜 休息关灯╭(╯ε╰)╮',
                category: 'life',
                important: false,
                createTime: new Date('2025-05-18T14:00:00').toISOString(),
                updateTime: new Date('2025-05-18T14:00:00').toISOString()
            },
            {
                id: Date.now() + 112,
                userId: userId,
                title: '2025.5.19  晴^O^',
                content: '这外面车声音太大了 我被吵醒了 然后看着熟睡的小宝 我试着叫了你 发现你还回应我 我说一句你嗯  再说一句还嗯小宝好乖啊嘿嘿   起来之后 收拾完我们出去吃了饭 我不知道豆花饭是什么 所以一直说那个 你还说是不是特别喜欢吃 我都没吃过呢  你是豌杂面  看着你吃了半碗就不吃了 这豆花吃着没味 我想了个小办法 直接拉辣椒和你的杂酱在混合豆花吃哈哈 吃完陪你到地铁站上去 我一直看着你进去  你都没看我哼 等呀等等到了晚上11点  看着你疲惫的眼神 我真的很心疼 要是能够在休息一天就好了 酒店的东西全都换了 说我聪明小傻瓜 嘿嘿 要12点的时候你都要睡着了我叫醒了你 给你准备的惊喜你都还没看 怎么能睡呢 看完再睡  我就呆呆的在旁边看着你看 看完之后抱着你睡觉啦 我真幸福！',
                category: 'life',
                important: false,
                createTime: new Date('2025-05-19T08:00:00').toISOString(),
                updateTime: new Date('2025-05-19T08:00:00').toISOString()
            },
            {
                id: Date.now() + 113,
                userId: userId,
                title: '2025.5.20  大太阳♥',
                content: '我们就是定了一个闹钟 又等一个闹钟 老大临时通知又叫早点去 我们决定12点下去  亲亲小宝 真的真的好舍不得又到那个场景了 我是排骨你是牛肉 你叫我补补  我才不虚你该多补补😁😁  我可是最强壮的man  后面呢 你打车 外面老晒了 先跑去公交车站 待一会车就来了 为什么时间如此之快呜呜呜  抱着你很想很想  看着你上车之后 我回了酒店躺一会就退房了 回万州 轻轨一上去就是直快 是真的快 我比你还先到了 下车又刚好直接进站 找到座位等高铁 太热了 太热了受不了 当时你说老吴给你点的有花 你和小张都不知道送啥给她 还讨论一下 最后说买吃的和口红再到后面就就是到时候再看了 坐上高铁看会电视 你也在上班了 到万州等公交车 那公交车站太阳都给它阴影晒反了 快下山了  但还是很大一个  做到学校先回寝室收拾东西 收拾完了在吃的饭 东西太重了 还是先到寝室  你呀今天的小宝是努力宝 很想睡觉 但一点也不敢休息 怕被老大看到 听你说还差点睡着了 真的很心疼 所以晚上你洗完澡就睡觉叭  我和你同一时间睡 么╭(╯ε╰)╮',
                category: 'life',
                important: false,
                createTime: new Date('2025-05-20T12:00:00').toISOString(),
                updateTime: new Date('2025-05-20T12:00:00').toISOString()
            },
            {
                id: Date.now() + 114,
                userId: userId,
                title: '2025.6.2  阴',
                content: '小宝休假日被调整了，最最最担心的是小宝手机落在车里了，真的不好联系到，不过小宝真聪明通过抖音和快手联系上我了。刚开始还在想是谁，点进去原来是小宝 我还以为小宝不理我了呢。后面在轻轨出口等小宝生怕小宝走错找不到你，后面还是等到了 到处望  小宝今天带我去吃了牛肉火锅，期待说是一直想带我吃。第二天极限进站累死我了  感觉比跑1000还累，回去又是坐车坐啊坐做到了  寝室里哈哈  睡觉好累辛苦小宝啦亲亲😘',
                category: 'life',
                important: false,
                createTime: new Date('2025-06-02T16:00:00').toISOString(),
                updateTime: new Date('2025-06-02T16:00:00').toISOString()
            }
        ]
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        allMemos.push(...adminMemos)
        uni.setStorageSync(this.memoKey, allMemos)
    }

    // 为测试管理员创建管理员相关的示例备忘录
    createTestAdminMemos(userId) {
        const testAdminMemos = [
            {
                id: Date.now() + 201,
                userId: userId,
                title: '系统管理员欢迎界面 🛠️',
                content: '🎉 欢迎使用小何备忘录管理系统！\n\n作为管理员，您拥有以下权限：\n• 查看所有用户数据\n• 管理系统设置\n• 监控应用运行状态\n• 处理用户反馈\n\n这是您的测试账号，用户名：admin，密码：admin123\n请妥善保管您的管理员凭据。💼',
                category: 'work',
                important: true,
                createTime: new Date('2025-01-01T09:00:00').toISOString(),
                updateTime: new Date('2025-01-01T09:00:00').toISOString()
            },
            {
                id: Date.now() + 202,
                userId: userId,
                title: '每日系统检查清单 ✅',
                content: '📋 管理员每日工作清单：\n\n☐ 检查系统运行状态\n☐ 查看用户反馈\n☐ 监控数据存储使用情况\n☐ 检查应用性能指标\n☐ 备份重要数据\n☐ 更新系统公告\n☐ 处理用户问题\n☐ 优化系统配置\n\n记得定期执行这些检查以确保系统稳定运行！🔧',
                category: 'work',
                important: false,
                createTime: new Date('2025-01-02T08:00:00').toISOString(),
                updateTime: new Date('2025-01-02T08:00:00').toISOString()
            },
            {
                id: Date.now() + 203,
                userId: userId,
                title: '用户数据分析报告 📊',
                content: '📈 2025年度用户使用情况分析：\n\n总用户数：1,234\n活跃用户：856\n新增用户：145\n平均备忘录数量：15.3条\n\n用户偏好分类：\n• 工作类：45%\n• 生活类：35%\n• 学习类：20%\n\n用户反馈满意度：4.7/5.0\n\n建议：继续优化用户体验，增加新功能。📝',
                category: 'work',
                important: false,
                createTime: new Date('2025-01-03T14:00:00').toISOString(),
                updateTime: new Date('2025-01-03T14:00:00').toISOString()
            },
            {
                id: Date.now() + 204,
                userId: userId,
                title: '系统维护计划 🔧',
                content: '🛠️ 本月系统维护安排：\n\n1. 数据库优化（1月15日）\n   - 清理冗余数据\n   - 优化查询性能\n   - 备份重要数据\n\n2. 安全更新（1月20日）\n   - 更新加密算法\n   - 强化用户数据保护\n   - 修复安全漏洞\n\n3. 功能升级（1月25日）\n   - 新增导出功能\n   - 优化界面体验\n   - 增加数据同步\n\n维护期间可能会短暂影响服务，请提前通知用户。⚠️',
                category: 'work',
                important: true,
                createTime: new Date('2025-01-05T10:00:00').toISOString(),
                updateTime: new Date('2025-01-05T10:00:00').toISOString()
            },
            {
                id: Date.now() + 205,
                userId: userId,
                title: '用户反馈处理记录 💬',
                content: '📞 近期用户反馈处理情况：\n\n✅ 已处理：\n• 修复了登录时的卡顿问题\n• 优化了备忘录搜索功能\n• 增加了数据导出选项\n• 改进了界面响应速度\n\n⏳ 处理中：\n• 添加标签分类功能\n• 支持多设备同步\n• 增加提醒功能\n\n📋 待处理：\n• 夜间模式支持\n• 语音备忘录功能\n• 团队协作功能\n\n用户满意度持续提升，继续保持！👍',
                category: 'work',
                important: false,
                createTime: new Date('2025-01-07T16:00:00').toISOString(),
                updateTime: new Date('2025-01-07T16:00:00').toISOString()
            },
            {
                id: Date.now() + 206,
                userId: userId,
                title: '安全审计报告 🔒',
                content: '🔐 系统安全状况评估：\n\n安全等级：A级\n\n✅ 安全检查项目：\n• 用户密码加密：正常\n• 数据传输安全：正常\n• 本地存储保护：正常\n• 权限控制：正常\n• 日志审计：正常\n\n⚠️ 注意事项：\n• 定期更新密码策略\n• 监控异常登录行为\n• 加强数据备份机制\n\n无发现安全漏洞，系统运行稳定安全。🛡️',
                category: 'work',
                important: true,
                createTime: new Date('2025-01-10T11:00:00').toISOString(),
                updateTime: new Date('2025-01-10T11:00:00').toISOString()
            },
            {
                id: Date.now() + 207,
                userId: userId,
                title: '管理员工作总结 📝',
                content: '📋 本周管理工作总结：\n\n🏆 主要成就：\n• 成功处理15个用户问题\n• 优化系统性能提升20%\n• 完成安全审计工作\n• 更新用户使用手册\n\n📈 数据指标：\n• 系统可用性：99.9%\n• 用户满意度：4.8/5\n• 响应时间：<200ms\n• 存储利用率：65%\n\n🎯 下周计划：\n• 推进新功能开发\n• 优化数据库性能\n• 准备系统升级\n• 培训客服团队\n\n继续为用户提供优质服务！💪',
                category: 'work',
                important: false,
                createTime: new Date('2025-01-12T17:00:00').toISOString(),
                updateTime: new Date('2025-01-12T17:00:00').toISOString()
            },
            {
                id: Date.now() + 208,
                userId: userId,
                title: '紧急事件处理预案 🚨',
                content: '🚨 系统紧急事件应急处理流程：\n\n🔴 一级事件（系统崩溃）：\n1. 立即启动备用系统\n2. 通知所有相关人员\n3. 分析故障原因\n4. 制定修复方案\n5. 实施修复措施\n6. 验证系统恢复\n7. 发布恢复公告\n\n🟡 二级事件（功能异常）：\n1. 评估影响范围\n2. 临时规避方案\n3. 排查问题根因\n4. 制定修复计划\n5. 测试修复效果\n6. 部署正式修复\n\n📞 紧急联系方式：\n• 技术负责人：138****8000\n• 运维团队：400-****-****\n\n时刻准备，快速响应！⚡',
                category: 'work',
                important: true,
                createTime: new Date('2025-01-15T09:30:00').toISOString(),
                updateTime: new Date('2025-01-15T09:30:00').toISOString()
            }
        ]
        
        const allMemos = uni.getStorageSync(this.memoKey) || []
        allMemos.push(...testAdminMemos)
        uni.setStorageSync(this.memoKey, allMemos)
    }

    // 清理并重新初始化所有管理员账号和备忘录
    resetAdminAccounts() {
        const users = uni.getStorageSync(this.userKey) || []
        let allMemos = uni.getStorageSync(this.memoKey) || []
        
        // 删除现有的管理员账号
        const filteredUsers = users.filter(user => 
            !(user.username === 'hechen' || user.username === 'admin') || !user.isAdmin
        )
        
        // 删除现有的管理员备忘录
        const filteredMemos = allMemos.filter(memo => {
            const memoUser = users.find(u => u.id === memo.userId)
            return !(memoUser && (memoUser.username === 'hechen' || memoUser.username === 'admin') && memoUser.isAdmin)
        })
        
        // 保存清理后的数据
        uni.setStorageSync(this.userKey, filteredUsers)
        uni.setStorageSync(this.memoKey, filteredMemos)
        
        // 重新初始化管理员账号
        this.initSuperAdmin()
        
        return {
            success: true,
            message: '管理员账号已重置，hechen手机号：13541489881，admin手机号：18290362536'
        }
    }

    // 调试：获取所有用户信息
    debugGetAllUsers() {
        const users = uni.getStorageSync(this.userKey) || []
        return users.map(user => ({
            id: user.id,
            username: user.username,
            phone: user.phone,
            isAdmin: user.isAdmin
        }))
    }

    // 调试：获取指定用户的备忘录
    debugGetUserMemos(userId) {
        const allMemos = uni.getStorageSync(this.memoKey) || []
        return allMemos.filter(memo => memo.userId === userId)
    }
}

// 创建单例实例
const storage = new LocalStorage()

// 导出单例实例（同时支持默认导出和命名导出）
export default storage
export { storage } 